package com.starleague.battletech.unit.mech;

import com.starleague.battletech.unit.IBattletechUnitInternalStructure;

public interface IMechInternalStructure
        extends IBattletechUnitInternalStructure, IMechComponent
{
    // HitPoints createHitPoints(final MechHitLocationType mechHitLocationType) throws BattletechException;
    //
    // //
    // //
    // //
    //
    // public static class Helper
    // {
    // public static Tons calculateTons(final IInternalStructure.TYPE i_internalStructureType, final Tons i_mechTons)
    // throws StarLeagueException
    // {
    // switch(i_internalStructureType)
    // {
    // case NORMAL:
    // return Tons.createFromCTons(i_mechTons.asCTons() / 10);
    // case ENDO_IS:
    // case ENDO_CLAN:
    // return Tons.createFromCTons(((i_mechTons.asCTons() + 999) / 1000) * 50);
    // // return ((i_mech.getTons().asCTons() + 900) / 1000) * 50;
    // default:
    // throw new StarLeagueException(
    // "MechInternalStructure: Unsupported InternalStructure.TYPE [" +
    // i_internalStructureType + "]");
    // }
    // }
    //
    // // 25 => 2.5 => 1.5 (1.25)
    // // 30 => 3 => 1.5
    // // 2500 + 900 = 3400 / 1000 = 3 * 50 = 150
    // // 3000 + 900 = 3900 / 1000 = 3 * 50 = 150
    //
    // public static int calculatePointsChartIndex(final Tons i_mechTons) throws StarLeagueException
    // {
    // final int pointsChartIndex = i_mechTons.asCTons() / 500;
    //
    // if ((pointsChartIndex < 0)
    // || (pointsChartIndex >= globalPointsChart.length)
    // || (globalPointsChart[pointsChartIndex] == null))
    // throw new StarLeagueException(
    // "MechInternalStructure.Helper.calculatePointsChartIndex(): mech weight {" +
    // i_mechTons + "} is out of range");
    //
    // return pointsChartIndex;
    // }
    //
    // public static HitPoints createHitPoints(final int i_pointsChartIndex, final IMechHitLocation.TYPE
    // i_mechHitLocationType) throws StarLeagueException
    // {
    // if ((i_pointsChartIndex < 0)
    // || (i_pointsChartIndex >= globalPointsChart.length)
    // || (globalPointsChart[i_pointsChartIndex] == null))
    // throw new StarLeagueException(
    // "MechInternalStructure.Helper.createHitPoints(): pointsChartIndex [" +
    // i_pointsChartIndex + "] is out of range");
    //
    // switch (i_mechHitLocationType)
    // {
    // case HEAD: return new HitPoints(globalPointsChart[i_pointsChartIndex][0]);
    // case CENTER_TORSO: return new HitPoints(globalPointsChart[i_pointsChartIndex][1]);
    // case SIDE_TORSO: return new HitPoints(globalPointsChart[i_pointsChartIndex][2]);
    // case ARM: return new HitPoints(globalPointsChart[i_pointsChartIndex][3]);
    // case LEG: return new HitPoints(globalPointsChart[i_pointsChartIndex][4]);
    // default: return null; // ASSERT: Can never happen (makes compiler happy)
    // }
    // }
    //
    // //
    // //
    // //
    //
    // private final static int[][] globalPointsChart =
    // {
    // //
    // // Internal_structure points a mech has, by [weight / 5]
    // //
    // // { HEAD, CENTER_TORSE, SIDE_TORSE, ARM, LEG }
    // //
    // null, // mech tonnage of 0 is invalid
    // null, // mech tonnage of 5 is invalid
    // null, // mech tonnage of 10 is invalid { 3, 4, 3, 1, 2 },
    // null, // mech tonnage of 15 is invalid { 3, 5, 4, 2, 3 },
    // { 3, 6, 5, 3, 4 }, // 20 tons
    // { 3, 8, 6, 4, 6 },
    // { 3, 10, 7, 5, 7 },
    // { 3, 11, 8, 6, 8 },
    // { 3, 12, 10, 6, 10 },
    // { 3, 14, 11, 7, 11 },
    // { 3, 16, 12, 8, 12 },
    // { 3, 18, 13, 9, 13 },
    // { 3, 20, 14, 10, 14 },
    // { 3, 21, 15, 10, 15 },
    // { 3, 22, 15, 11, 15 }, // 70 tons
    // { 3, 23, 16, 12, 16 },
    // { 3, 25, 17, 13, 17 },
    // { 3, 27, 18, 14, 18 },
    // { 3, 29, 19, 15, 19 },
    // { 3, 30, 20, 16, 20 },
    // { 3, 31, 21, 17, 21 }, // 100 tons
    // // { 105, 4, 32, 22, 17, 22 },
    // // { 110, 4, 33, 23, 18, 23 },
    // // { 115, 4, 35, 24, 19, 24 },
    // // { 120, 4, 36, 25, 20, 25 },
    // // { 125, 4, 38, 26, 21, 26 },
    // // { 130, 4, 39, 27, 21, 27 },
    // // { 135, 4, 41, 28, 22, 28 },
    // // { 140, 4, 42, 29, 23, 29 },
    // // { 145, 4, 44, 31, 24, 31 },
    // // { 150, 4, 45, 32, 25, 32 },
    // // { 155, 4, 47, 33, 26, 33 },
    // // { 160, 4, 48, 34, 26, 34 },
    // // { 165, 4, 50, 35, 27, 35 },
    // // { 170, 4, 51, 36, 28, 36 },
    // // { 175, 4, 53, 37, 29, 37 },
    // // { 180, 4, 54, 38, 30, 38 },
    // // { 185, 4, 56, 39, 31, 39 },
    // // { 190, 4, 57, 40, 31, 40 },
    // // { 195, 4, 59, 41, 32, 41 },
    // // { 200, 4, 60, 42, 33, 42 }
    // };
    // }
}
// public MechInternalStructureLocation getLocation(final MechHitLocation.POSITION i_mechHitLocationPOSITION)
// {
// return this.position_location_map.get(i_mechHitLocationPOSITION);
// }
//
// public static MechInternalStructure create(
// final InternalStructure.TYPE i_internalStructureType,
// final int i_mech_tons,
// final MechMovement.TYPE i_mechMovementType) throws StarLeagueException
// {
// if ((i_mech_tons % 5) != 0)
// throw new StarLeagueException(
// "MechInternalStructure: mech weight [" +
// i_mech_tons + "] is not divisible by 5");
//
// //
// // Lookup Mech mass in the table (at bottom)
// //
//
// final int pointsChartIndex = i_mech_tons / 5;
//
// if ((pointsChartIndex < 0)
// || (pointsChartIndex >= globalPointsChart.length)
// || (globalPointsChart[pointsChartIndex] == null))
// throw new StarLeagueException(
// "MechInternalStructure: mech weight [" +
// i_mech_tons + "] is out of range");
//
// final int tmpCTons;
//
// switch(i_internalStructureType)
// {
// case NORMAL:
// tmpCTons = i_mech_tons * 10;
// break;
// case ENDO_IS:
// case ENDO_CLAN:
// tmpCTons = ((i_mech_tons + 9) / 10) * 50;
// break;
// default:
// throw new StarLeagueException(
// "MechInternalStructure: Unsupported InternalStructure.TYPE [" +
// i_internalStructureType + "]");
// }
//
// return new MechInternalStructure(
// i_internalStructureType,
// tmpCTons,
// pointsChartIndex,
// i_mechMovementType);
// }
//
// //
// //
// //
//
// private MechInternalStructure(
// final InternalStructure.TYPE i_internalStructureType,
// final int i_ctons,
// final int i_pointsChartIndex,
// final MechMovement.TYPE i_mechMovementType)
// {
// super(i_internalStructureType, i_ctons);
//
// this.position_location_map =
// new HashMap<MechHitLocation.POSITION, MechInternalStructureLocation>();
//
// addLocation(MechHitLocation.POSITION.HEAD, i_pointsChartIndex);
// addLocation(MechHitLocation.POSITION.CENTER_TORSO, i_pointsChartIndex);
// addLocation(MechHitLocation.POSITION.LEFT_TORSO, i_pointsChartIndex);
// addLocation(MechHitLocation.POSITION.RIGHT_TORSO, i_pointsChartIndex);
// addLocation(MechHitLocation.POSITION.LEFT_LEG, i_pointsChartIndex);
// addLocation(MechHitLocation.POSITION.RIGHT_LEG, i_pointsChartIndex);
//
// switch (i_mechMovementType)
// {
// case BIPED:
//
// addLocation(MechHitLocation.POSITION.LEFT_ARM, i_pointsChartIndex);
// addLocation(MechHitLocation.POSITION.RIGHT_ARM, i_pointsChartIndex);
// break;
//
// case QUADRUPED:
// addLocation(MechHitLocation.POSITION.LEFT_LEG_FRONT, i_pointsChartIndex);
// addLocation(MechHitLocation.POSITION.RIGHT_LEG_FRONT, i_pointsChartIndex);
// break;
// }
// }
//
// private MechInternalStructureLocation addLocation(
// final MechHitLocation.POSITION i_position,
// final int i_pointsChartIndex)
// {
// final int pointsChartOffset;
// switch (i_position.mechHitLocationType)
// {
// case HEAD: pointsChartOffset = 0; break;
// case CENTER_TORSO: pointsChartOffset = 1; break;
// case SIDE_TORSO: pointsChartOffset = 2; break;
// case ARM: pointsChartOffset = 3; break;
// case LEG: pointsChartOffset = 4; break;
// default: pointsChartOffset = -1; // ASSERT: Can never happen (makes compiler happy)
// }
//
// final MechInternalStructureLocation newLocation =
// new MechInternalStructureLocation(
// this,
// i_position,
// globalPointsChart[i_pointsChartIndex][pointsChartOffset]);
//
// this.position_location_map.put(i_position, newLocation);
//
// return newLocation;
// }

//
//
//

// @OneToMany(mappedBy="mechInternalStructure", cascade=CascadeType.ALL)
// @MapKey(name="position")
// private Map<MechHitLocation.POSITION, MechInternalStructureLocation> position_location_map;

// //@Entity
// public class MechInternalStructure extends InternalStructure implements ICriticalSlot.Anywhere, IWeightCTons
// {
// @Override
// public String toString()
// {
// return getName();
// }
//
// // @Override
// public String getName() { return "InternalStructure [" + this.getInternalStructureTYPE() + "]"; }
//
// // @Override
// public boolean IsReRoll() { return true; }
//
// // @Override
// public int getCTons() { return this.ctons; }
//
// public MechInternalStructure(
// final InternalStructure.TYPE i_internal_structure_type,
// final int i_mech_tons) throws BattletechException
// {
// super(i_internal_structure_type);
//
// if ((i_mech_tons % 5) != 0)
// throw new BattletechException(
// "MechDesignerInternalStructure.ctor(): mech weight [" +
// i_mech_tons + "] is not divisible by 5");
//
// //
// // Lookup Mech mass in the table (at bottom)
// //
//
// points_chart_index = i_mech_tons / 5;
//
// if ((this.points_chart_index < 0)
// || (this.points_chart_index >= MechInternalStructure.global_points_chart.length)
// || (MechInternalStructure.global_points_chart[this.points_chart_index] == null))
// throw new BattletechException(
// "MechDesignerInternalStructure.ctor(): mech weight [" +
// i_mech_tons + "] is out of range");
//
// switch(i_internal_structure_type)
// {
// case NORMAL:
// this.ctons = i_mech_tons * 10;
// break;
// case ENDO_IS:
// case ENDO_CLAN:
// this.ctons = ((i_mech_tons + 9) / 10) * 50;
// break;
// default:
// this.ctons = -1; // Make compiler happy
// }
// }
//
// public int getMaxPointsInHitLocation(final MechHitLocation.TYPE i_hit_location_type)
// {
// switch(i_hit_location_type)
// {
// case HEAD:
// return MechInternalStructure.global_points_chart[this.points_chart_index][0];
// case CENTER_TORSO:
// return MechInternalStructure.global_points_chart[this.points_chart_index][1];
// case SIDE_TORSO:
// return MechInternalStructure.global_points_chart[this.points_chart_index][2];
// case ARM:
// return MechInternalStructure.global_points_chart[this.points_chart_index][3];
// case LEG:
// return MechInternalStructure.global_points_chart[this.points_chart_index][4];
// }
//
// // NOTE: This should NEVER happen (switch should always succeed), but is here for the compiler!
// return -1;
// }

// public final boolean addToHitLocations(final HitLocation... i_hit_locations)
// {
// switch(this.getInternalStructureTYPE())
// {
// case NORMAL:
// return true;
// case ENDO_IS:
// return AddToRandomHitLocations(14, i_hit_locations);
// case ENDO_CLAN:
// return AddToRandomHitLocations(7, i_hit_locations);
// default:
// return false;
// }
// }
//
// private boolean AddToRandomHitLocations(
// final int i_num_slots,
// final HitLocation... i_hit_locations)
// {
// int slots_remaining = i_num_slots;
// for(HitLocation hit_location : i_hit_locations)
// {
// while(slots_remaining > 0)
// {
// if (!hit_location.addICriticalSlot(this, 1))
// break;
// // else
// --slots_remaining;
// }
// }
//
// if (slots_remaining > 0)
// {
// // Have to remove all added slots before returning failure
// for(HitLocation hit_location : i_hit_locations)
// {
// hit_location.removeICriticalSlot(this);
// }
// return false;
// }
// // else
// return true;
// }
//
// public int getNumCriticalSlots()
// {
// switch(this.getInternalStructureTYPE())
// {
// case NORMAL:
// return 0;
// case ENDO_IS:
// return 14;
// case ENDO_CLAN:
// return 7;
// }
// return -1; // make the compiler happy
// }
//
// //
// //
// //
//
// private int points_chart_index;
// private int ctons;
//
// //
// //
// //
//
// private final static int[][] global_points_chart =
// {
// //
// // Internal_structure points a mech has, by [weight / 5]
// //
// // { HEAD, CENTER_TORSE, SIDE_TORSE, ARM, LEG }
// //
// null, // mech tonnage of 0 is invalid
// null, // mech tonnage of 5 is invalid
// null, // mech tonnage of 10 is invalid { 3, 4, 3, 1, 2 },
// null, // mech tonnage of 15 is invalid { 3, 5, 4, 2, 3 },
// { 3, 6, 5, 3, 4 }, // 20 tons
// { 3, 8, 6, 4, 6 },
// { 3, 10, 7, 5, 7 },
// { 3, 11, 8, 6, 8 },
// { 3, 12, 10, 6, 10 },
// { 3, 14, 11, 7, 11 },
// { 3, 16, 12, 8, 12 },
// { 3, 18, 13, 9, 13 },
// { 3, 20, 14, 10, 14 },
// { 3, 21, 15, 10, 15 },
// { 3, 22, 15, 11, 15 }, // 70 tons
// { 3, 23, 16, 12, 16 },
// { 3, 25, 17, 13, 17 },
// { 3, 27, 18, 14, 18 },
// { 3, 29, 19, 15, 19 },
// { 3, 30, 20, 16, 20 },
// { 3, 31, 21, 17, 21 }, // 100 tons
// // { 105, 4, 32, 22, 17, 22 },
// // { 110, 4, 33, 23, 18, 23 },
// // { 115, 4, 35, 24, 19, 24 },
// // { 120, 4, 36, 25, 20, 25 },
// // { 125, 4, 38, 26, 21, 26 },
// // { 130, 4, 39, 27, 21, 27 },
// // { 135, 4, 41, 28, 22, 28 },
// // { 140, 4, 42, 29, 23, 29 },
// // { 145, 4, 44, 31, 24, 31 },
// // { 150, 4, 45, 32, 25, 32 },
// // { 155, 4, 47, 33, 26, 33 },
// // { 160, 4, 48, 34, 26, 34 },
// // { 165, 4, 50, 35, 27, 35 },
// // { 170, 4, 51, 36, 28, 36 },
// // { 175, 4, 53, 37, 29, 37 },
// // { 180, 4, 54, 38, 30, 38 },
// // { 185, 4, 56, 39, 31, 39 },
// // { 190, 4, 57, 40, 31, 40 },
// // { 195, 4, 59, 41, 32, 41 },
// // { 200, 4, 60, 42, 33, 42 }
// };
// }
//
// //
//
//

// @Override
// public boolean IsValidHitLocationTYPE(final MechHitLocation.TYPE i_mech_hit_location_type) { return true; }

// public MechInternalStructure(
// final MechInternalStructure.SerialData i_mech_internal_structure_data)// throws BattletechException
// {
// super(i_mech_internal_structure_data);
//
// _points_chart_index = i_mech_internal_structure_data._points_chart_index;
// _ctons = i_mech_internal_structure_data._ctons;
// }
// @Override
// public MechInternalStructure.SerialData Serialize(final SerialObject.SerialManager i_sobject_manager)
// {
// return new MechInternalStructure.SerialData(i_sobject_manager, this);
// }
//
// public static class SerialData extends InternalStructure.SerialData
// {
// @Override
// public MechInternalStructure Deserialize(final SerialObject.SerialManager i_sobject_manager)// throws
// BattletechException
// {
// return (MechInternalStructure)i_sobject_manager.TrackSerialObject(new MechInternalStructure(this), this);
// }
//
// final int _points_chart_index;
// final int _ctons;
//
// SerialData(final SerialObject.SerialManager i_sobject_manager, final MechInternalStructure i_mech_internal_structure)
// {
// super(i_sobject_manager, i_mech_internal_structure);
//
// _points_chart_index = i_mech_internal_structure._points_chart_index;
// _ctons = i_mech_internal_structure._ctons;
// }
// }

//
// public MechInternalStructure(
// final MechDesignerInternalStructure i_mech_designer_internal_structure)
// throws BattletechException
// {
// super(i_mech_designer_internal_structure.getTYPE());
// }

// public List<battletech.mech.MechDesign.CriticalSlotableToPlace> getCriticalSlotablesToPlace()
// {
// int num_slots = 0;
// switch(getTYPE())
// {
// case NORMAL:
// break; // num_slots = 0
// case ENDO_IS:
// num_slots = 14;
// break;
// case ENDO_CLAN:
// num_slots = 7;
// break;
// }
//
// if (num_slots <= 0)
// return null;
// // else
// ArrayList<battletech.mech.MechDesign.CriticalSlotableToPlace> slot_array =
// new ArrayList<battletech.mech.MechDesign.CriticalSlotableToPlace>(num_slots);
//
// for(int i = 0;i < num_slots;++i)
// slot_array.add(
// new battletech.mech.MechDesign.CriticalSlotableToPlace(
// battletech.mech.MechDesign.HIT_LOCATION.values(),
// this));
//
// return slot_array;
// }
//
// public int getPointsInHitLocation(final HitLocation.TYPE i_hit_location_type) throws BattletechException
// {
// switch(i_hit_location_type)
// {
// case HEAD:
// return _points_chart[_points_chart_index][0];
// case CENTER_TORSO:
// return _points_chart[_points_chart_index][1];
// case SIDE_TORSO:
// return _points_chart[_points_chart_index][2];
// case ARM:
// return _points_chart[_points_chart_index][3];
// case LEG:
// return _points_chart[_points_chart_index][4];
// }
//
// // NOTE: This should NEVER happen (switch should always succeed), but is here for the compiler!
// throw new BattletechException(
// "battletech.mech.InternalStructure.getPointsInHitLocation(): invalid mech HitLocation.TYPE [" +
// i_hit_location_type + "]");
// }
//
// //private final int _mech_weight;
// private final int _points_chart_index;
// private final int _ctons;
//
// private final static int[][] _points_chart =
// {
// //
// // Internal_structure points a mech has, by [weight / 5]
// //
// // { HEAD, CENTER_TORSE, SIDE_TORSE, ARM, LEG }
// //
// null, // mech tonnage of 0 is invalid
// null, // mech tonnage of 5 is invalid
// null, // mech tonnage of 10 is invalid { 3, 4, 3, 1, 2 },
// null, // mech tonnage of 15 is invalid { 3, 5, 4, 2, 3 },
// { 3, 6, 5, 3, 4 }, // 20 tons
// { 3, 8, 6, 4, 6 },
// { 3, 10, 7, 5, 7 },
// { 3, 11, 8, 6, 8 },
// { 3, 12, 10, 6, 10 },
// { 3, 14, 11, 7, 11 },
// { 3, 16, 12, 8, 12 },
// { 3, 18, 13, 9, 13 },
// { 3, 20, 14, 10, 14 },
// { 3, 21, 15, 10, 15 },
// { 3, 22, 15, 11, 15 }, // 70 tons
// { 3, 23, 16, 12, 16 },
// { 3, 25, 17, 13, 17 },
// { 3, 27, 18, 14, 18 },
// { 3, 29, 19, 15, 19 },
// { 3, 30, 20, 16, 20 },
// { 3, 31, 21, 17, 21 }, // 100 tons
// // { 105, 4, 32, 22, 17, 22 },
// // { 110, 4, 33, 23, 18, 23 },
// // { 115, 4, 35, 24, 19, 24 },
// // { 120, 4, 36, 25, 20, 25 },
// // { 125, 4, 38, 26, 21, 26 },
// // { 130, 4, 39, 27, 21, 27 },
// // { 135, 4, 41, 28, 22, 28 },
// // { 140, 4, 42, 29, 23, 29 },
// // { 145, 4, 44, 31, 24, 31 },
// // { 150, 4, 45, 32, 25, 32 },
// // { 155, 4, 47, 33, 26, 33 },
// // { 160, 4, 48, 34, 26, 34 },
// // { 165, 4, 50, 35, 27, 35 },
// // { 170, 4, 51, 36, 28, 36 },
// // { 175, 4, 53, 37, 29, 37 },
// // { 180, 4, 54, 38, 30, 38 },
// // { 185, 4, 56, 39, 31, 39 },
// // { 190, 4, 57, 40, 31, 40 },
// // { 195, 4, 59, 41, 32, 41 },
// // { 200, 4, 60, 42, 33, 42 }
// };
// }
